package com.christina.engine.response.decorator.impl;

import com.christina.engine.response.decorator.ResponseDecorator;
import com.christina.engine.response.decorator.ResponseGenerator;
import com.christina.engine.response.model.ResponseContext;
import com.christina.engine.response.model.ResponseResult;
import org.springframework.stereotype.Component;

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.regex.Pattern;

/**
 * 格式化响应装饰器
 * 对响应内容进行格式化处理，提升可读性
 * 
 * @author Christina
 */
@Component
public class FormattingResponseDecorator extends ResponseDecorator {
    
    private static final String DECORATOR_NAME = "FormattingDecorator";
    private static final int PRIORITY = 300; // 中等优先级
    
    // 格式化相关的正则表达式
    private static final Pattern MULTIPLE_SPACES = Pattern.compile("\\s+");
    private static final Pattern MULTIPLE_NEWLINES = Pattern.compile("\n{3,}");
    private static final Pattern TRAILING_SPACES = Pattern.compile("[ \t]+$", Pattern.MULTILINE);
    
    public FormattingResponseDecorator(ResponseGenerator wrapped) {
        super(wrapped, DECORATOR_NAME, PRIORITY);
    }
    
    // 无参构造函数，用于Spring注入
    public FormattingResponseDecorator() {
        super(null, DECORATOR_NAME, PRIORITY);
    }
    
    @Override
    protected ResponseResult decorate(ResponseContext context, ResponseResult result) {
        return doDecorate(result, context);
    }
    
    @Override
    protected ResponseResult doDecorate(ResponseResult result, ResponseContext context) {
        if (!result.isSuccess() || result.getContent() == null) {
            return result;
        }
        
        String originalContent = result.getContent();
        String formattedContent = formatContent(originalContent, context);
        
        // 创建新的响应结果
        ResponseResult formattedResult = ResponseResult.builder()
                .content(formattedContent)
                .responseType(result.getResponseType())
                .success(result.isSuccess())
                .errorMessage(result.getErrorMessage())
                .generatedTime(result.getGeneratedTime())
                .generationDurationMs(result.getGenerationDurationMs())
                .generatorName(result.getGeneratorName())
                .qualityScore(calculateFormattedQualityScore(result.getQualityScore(), originalContent, formattedContent))
                .metadata(result.getMetadata())
                .build();
        
        // 添加格式化相关的元数据
        formattedResult.addMetadata("formatted", true);
        formattedResult.addMetadata("original_length", originalContent.length());
        formattedResult.addMetadata("formatted_length", formattedContent.length());
        formattedResult.addMetadata("formatting_improvement", 
                calculateFormattingImprovement(originalContent, formattedContent));
        
        logger.debug("内容格式化完成 - RequestId: {}, OriginalLength: {}, FormattedLength: {}", 
                context.getRequestId(), 
                originalContent.length(), 
                formattedContent.length());
        
        return formattedResult;
    }
    
    /**
     * 格式化内容
     * 
     * @param content 原始内容
     * @param context 响应上下文
     * @return 格式化后的内容
     */
    private String formatContent(String content, ResponseContext context) {
        if (content == null || content.trim().isEmpty()) {
            return content;
        }
        
        String formatted = content;
        
        // 1. 清理多余的空白字符
        formatted = cleanWhitespace(formatted);
        
        // 2. 格式化列表和编号
        formatted = formatLists(formatted);
        
        // 3. 格式化时间和日期
        formatted = formatDatesAndTimes(formatted);
        
        // 4. 添加适当的标点符号
        formatted = improvePunctuation(formatted);
        
        // 5. 根据用户偏好调整格式
        formatted = applyUserPreferences(formatted, context);
        
        // 6. 添加礼貌用语和个性化元素
        formatted = addPersonalization(formatted, context);
        
        return formatted.trim();
    }
    
    /**
     * 清理空白字符
     * 
     * @param content 内容
     * @return 清理后的内容
     */
    private String cleanWhitespace(String content) {
        // 移除行尾空格
        content = TRAILING_SPACES.matcher(content).replaceAll("");
        
        // 合并多个空格为单个空格
        content = MULTIPLE_SPACES.matcher(content).replaceAll(" ");
        
        // 限制连续换行不超过两个
        content = MULTIPLE_NEWLINES.matcher(content).replaceAll("\n\n");
        
        return content;
    }
    
    /**
     * 格式化列表和编号
     * 
     * @param content 内容
     * @return 格式化后的内容
     */
    private String formatLists(String content) {
        // 格式化数字列表
        content = content.replaceAll("(\\d+)\\s*[.。]\\s*", "$1. ");
        
        // 格式化项目符号列表
        content = content.replaceAll("[-*•]\\s*", "• ");
        
        // 确保列表项之间有适当的间距
        content = content.replaceAll("(• .+)\n(• )", "$1\n\n$2");
        
        return content;
    }
    
    /**
     * 格式化日期和时间
     * 
     * @param content 内容
     * @return 格式化后的内容
     */
    private String formatDatesAndTimes(String content) {
        // 这里可以添加日期时间格式化逻辑
        // 例如：将"2024-12-25"格式化为"2024年12月25日"
        
        // 格式化时间范围
        content = content.replaceAll("(\\d{1,2}):(\\d{2})-(\\d{1,2}):(\\d{2})", "$1:$2-$3:$4");
        
        return content;
    }
    
    /**
     * 改善标点符号
     * 
     * @param content 内容
     * @return 改善后的内容
     */
    private String improvePunctuation(String content) {
        // 确保句子以适当的标点符号结尾
        if (!content.matches(".*[.!?。！？]\\s*$")) {
            content += "。";
        }
        
        // 修复标点符号前的空格
        content = content.replaceAll("\\s+([,.!?;:。，！？；：])", "$1");
        
        // 确保标点符号后有适当的空格
        content = content.replaceAll("([.!?。！？])([A-Za-z\\u4e00-\\u9fa5])", "$1 $2");
        
        return content;
    }
    
    /**
     * 应用用户偏好
     * 
     * @param content 内容
     * @param context 响应上下文
     * @return 应用偏好后的内容
     */
    private String applyUserPreferences(String content, ResponseContext context) {
        if (context.getUserPreferences() == null) {
            return content;
        }
        
        // 根据用户偏好调整格式
        Object languagePreference = context.getUserPreferences().get("language");
        if ("en".equals(languagePreference)) {
            // 英语用户的格式化偏好
            content = content.replaceAll("。", ".");
            content = content.replaceAll("，", ",");
        }
        
        // 根据用户偏好的详细程度调整
        Object detailLevel = context.getUserPreferences().get("detailLevel");
        if ("concise".equals(detailLevel)) {
            content = makeConcise(content);
        } else if ("detailed".equals(detailLevel)) {
            content = addDetails(content);
        }
        
        return content;
    }
    
    /**
     * 添加个性化元素
     * 
     * @param content 内容
     * @param context 响应上下文
     * @return 个性化后的内容
     */
    private String addPersonalization(String content, ResponseContext context) {
        StringBuilder personalizedContent = new StringBuilder(content);
        
        // 根据时间添加问候语
        LocalDateTime now = LocalDateTime.now();
        int hour = now.getHour();
        
        if (!content.contains("祝您") && !content.contains("祝你")) {
            if (hour >= 6 && hour < 12) {
                personalizedContent.append("\n\n祝您早上愉快！");
            } else if (hour >= 12 && hour < 18) {
                personalizedContent.append("\n\n祝您下午愉快！");
            } else if (hour >= 18 && hour < 22) {
                personalizedContent.append("\n\n祝您晚上愉快！");
            }
        }
        
        // 添加时间戳（如果需要）
        if (context.hasData("includeTimestamp") && 
            Boolean.TRUE.equals(context.getData("includeTimestamp", Boolean.class))) {
            String timestamp = now.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm"));
            personalizedContent.append("\n\n生成时间：").append(timestamp);
        }
        
        return personalizedContent.toString();
    }
    
    /**
     * 使内容更简洁
     * 
     * @param content 内容
     * @return 简洁后的内容
     */
    private String makeConcise(String content) {
        // 移除冗余的词汇
        content = content.replaceAll("非常|十分|特别|极其", "");
        content = content.replaceAll("\\s+", " ");
        
        // 简化句式
        content = content.replaceAll("我建议您可以", "建议");
        content = content.replaceAll("您可以考虑", "可以");
        
        return content.trim();
    }
    
    /**
     * 添加详细信息
     * 
     * @param content 内容
     * @return 详细化后的内容
     */
    private String addDetails(String content) {
        // 这里可以添加更多详细信息的逻辑
        // 例如添加解释性文字、背景信息等
        return content;
    }
    
    /**
     * 计算格式化后的质量分数
     * 
     * @param originalScore 原始质量分数
     * @param originalContent 原始内容
     * @param formattedContent 格式化后的内容
     * @return 新的质量分数
     */
    private double calculateFormattedQualityScore(double originalScore, String originalContent, String formattedContent) {
        double improvement = calculateFormattingImprovement(originalContent, formattedContent);
        
        // 格式化改进可以提升质量分数，但不超过1.0
        return Math.min(1.0, originalScore + improvement * 0.1);
    }
    
    /**
     * 计算格式化改进程度
     * 
     * @param originalContent 原始内容
     * @param formattedContent 格式化后的内容
     * @return 改进程度 (0.0 - 1.0)
     */
    private double calculateFormattingImprovement(String originalContent, String formattedContent) {
        if (originalContent == null || formattedContent == null) {
            return 0.0;
        }
        
        double score = 0.0;
        
        // 检查空白字符改进
        int originalWhitespaceIssues = countWhitespaceIssues(originalContent);
        int formattedWhitespaceIssues = countWhitespaceIssues(formattedContent);
        if (originalWhitespaceIssues > formattedWhitespaceIssues) {
            score += 0.3;
        }
        
        // 检查标点符号改进
        int originalPunctuationIssues = countPunctuationIssues(originalContent);
        int formattedPunctuationIssues = countPunctuationIssues(formattedContent);
        if (originalPunctuationIssues > formattedPunctuationIssues) {
            score += 0.3;
        }
        
        // 检查结构改进
        if (hasImprovedStructure(originalContent, formattedContent)) {
            score += 0.4;
        }
        
        return Math.min(1.0, score);
    }
    
    /**
     * 计算空白字符问题数量
     * 
     * @param content 内容
     * @return 问题数量
     */
    private int countWhitespaceIssues(String content) {
        int issues = 0;
        
        // 多个连续空格
        if (content.contains("  ")) {
            issues++;
        }
        
        // 行尾空格
        if (content.matches(".*[ \t]+\n.*")) {
            issues++;
        }
        
        // 过多的换行
        if (content.contains("\n\n\n")) {
            issues++;
        }
        
        return issues;
    }
    
    /**
     * 计算标点符号问题数量
     * 
     * @param content 内容
     * @return 问题数量
     */
    private int countPunctuationIssues(String content) {
        int issues = 0;
        
        // 标点符号前有空格
        if (content.matches(".*\\s+[,.!?;:。，！？；：].*")) {
            issues++;
        }
        
        // 句子没有以标点符号结尾
        if (!content.trim().matches(".*[.!?。！？]$")) {
            issues++;
        }
        
        return issues;
    }
    
    /**
     * 检查结构是否有改进
     * 
     * @param originalContent 原始内容
     * @param formattedContent 格式化后的内容
     * @return 是否有改进
     */
    private boolean hasImprovedStructure(String originalContent, String formattedContent) {
        // 检查是否添加了列表格式
        boolean originalHasList = originalContent.contains("•") || originalContent.matches(".*\\d+\\..*");
        boolean formattedHasList = formattedContent.contains("•") || formattedContent.matches(".*\\d+\\..*");
        
        if (!originalHasList && formattedHasList) {
            return true;
        }
        
        // 检查是否添加了个性化元素
        boolean originalHasPersonalization = originalContent.contains("祝您");
        boolean formattedHasPersonalization = formattedContent.contains("祝您");
        
        return !originalHasPersonalization && formattedHasPersonalization;
    }
    
    /**
     * 创建包装指定生成器的格式化装饰器
     * 
     * @param generator 要包装的生成器
     * @return 格式化装饰器实例
     */
    public static FormattingResponseDecorator wrap(ResponseGenerator generator) {
        return new FormattingResponseDecorator(generator);
    }
}